<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
</head>
<body>
  
</body>
</html>

<script>
  // 数组去重

  var arr = [1,3,5,7,5,5,5,5,4,3,9,1];
  // [1,3,5,7,4,9];


  // 1. 两层循环，后面的元素和前面比较，如果相同，用splice方法删除
  // function fn1(arr) {
  //   if (!Array.isArray(arr)) return;
  //   for (var i = 0; i < arr.length; i++) {
  //     for (var j = i + 1; j < arr.length; j++) {
  //       // 它后面的元素依次和这个元素做比较，相同的删除
  //       if (arr[i] === arr[j]) {
  //         arr.splice(j, 1);
  //         j--;
  //       }
  //     }
  //   }
  //   return arr;
  // }
  // console.log(fn1(arr))






  // 2. 先排序，再放到一个新数组
  // function fn2(arr) {
  //   if (!Array.isArray(arr)) return;
  //   // 先数组排序, [1, 1, 3, 3, 4, 5, 5, 5, 5, 5, 7, 9]
  //   arr.sort(function(a, b) {
  //     return a - b;
  //   })
  //   var newArr = [];
  //   for (var i = 0; i < arr.length; i++) {
  //     // 判断的是循环过去的那一项是否等于新数组的最后一项
  //     if (arr[i] !== newArr[newArr.length - 1]) {
  //       newArr.push(arr[i]);
  //     }
  //   }
  //   return newArr;
  // }
  // console.log(fn2(arr))






  // 3. 先排序，用filter方法进行筛选
  
  // function fn3(arr) {
  //   if (!Array.isArray(arr)) return;
  //   // 先数组排序, [1, 1, 3, 3, 4, 5, 5, 5, 5, 5, 7, 9]
  //   arr.sort(function(a, b) {
  //     return a - b;
  //   })
  //   return arr.filter(function(item, index) {
  //     return arr[index] !== arr[index + 1];
  //   })
  // }
  // console.log(fn3(arr))







  // 4. 先创建一个空数组，循环旧数组，进行添加
  // function fn4(arr) {
  //   if (!Array.isArray(arr)) return;
  //   var newArr = [];
    
  //   // 循环旧数组
  //   arr.forEach(function(item, index) {
  //     // 判断新数组里面是否有循环到的老数组的这个元素
  //     // 如果没有出现过就往新数组里面加
  //     if (!newArr.includes(item)) {
  //       newArr.push(item)
  //     }
  //   })
  //   return newArr;
  // }
  // console.log(fn4(arr))









  // 5. 用indexof和lastIndexOf处理元素，再用splice方法删除
  // function fn5(arr) {
  //   if (!Array.isArray(arr)) return;
  //   // [1,3,5,7,5,5,5,5,4,3,9,1]

  //   // indexof和lastIndexOf的结果如果相同，说明这个元素只出现过一次
  //   // indexof和lastIndexOf的结果如果不相同，说明这个元素只出现过至少一次
  //   // console.log(arr.indexOf(5));
  //   // console.log(arr.lastIndexOf(5));
  //   for (var i = 0; i < arr.length; i++) {
  //     if (arr.indexOf(arr[i]) !== arr.lastIndexOf(arr[i])) {
  //       arr.splice(i, 1)
  //       i--;
  //     }
  //   }
  //   return arr
  // }
  // console.log(fn5(arr));









  // 6. 用indexOf的结果和i做比较,再用splice方法删除或者用filter过滤
  // [1,3,5,7,5,5,5,5,4,3,9,1]
  // function fn6(arr) {
  //   if (!Array.isArray(arr)) return;
  //   // for (var i = 0; i < arr.length; i++) {
  //   //   if (arr.indexOf(arr[i]) !== i) {
  //   //     arr.splice(i, 1)
  //   //     i--;
  //   //   }
  //   // }
  //   // return arr;
  //   return arr.filter(function(item, index) {
  //     return arr.indexOf(item) === index
  //   })
  // }
  // console.log(fn6(arr))





  // 7. 用es6新增的Set构造函数
  // Set是一种新的数据结构，不允许内部有重复的成员
  // var arr = new Set([1,2,3,3,3,4,2]);

  // 将Set结构转成数组结构
  // 做法和类数组转数组一摸一样

  // ...叫做展开运算符(扩展运算符)
  // 展开运算符可以将set类型或者类数组转成真正的数组
  // console.log([...arr]);
  // 也可以使用Array.from()方法将set类型或者类数组转成真正的数组
  // console.log(Array.from(arr));

  // console.log([...new Set(arr)])






  // 浅拷贝
  // 希望创建一个obj2，让obj2的值和obj一样
  // 但是当我改变obj的时候，希望obj2不要一起改变
  // var obj = {
  //   a: 3,
  //   b: 4,
  // }
  // var obj2 = {...obj};
  // // var obj2 = Object.assign({}, obj); // Object.assign用于对象拼接，类似于数组的concat
  // console.log(obj2);
  // obj.a = 30;
  // console.log(obj);
  // console.log(obj2);


  // var arr = [1,2,3,4,5];
  // var arr2 = [...arr];
  // var arr2 = [].concat(arr);






</script>